#include "DopplerGroupTab.h"
#include "ui_DopplerGroupTab.h"
#include <configure/DopplerConfigure.h>
#include <QPushButton>

DopplerGroupTab::DopplerGroupTab(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::DopplerGroupTab)
{
    ui->setupUi(this);
    m_pConfig = DopplerConfigure::Instance()  ;
    m_nGroupId = 0 ;
    UpdateGroupConfig (m_nGroupId);
    ui->toolBox->setCurrentIndex(0);
}

DopplerGroupTab::~DopplerGroupTab ()
{
    delete ui;
}

void DopplerGroupTab::SetGroupId(int nGroupId_)
{
    m_nGroupId = nGroupId_ ;
}

QToolBox* DopplerGroupTab::GetToolBox() const
{
    return ui->toolBox ;
}

void DopplerGroupTab::InitConfig()
{
}

void DopplerGroupTab::UpdateVelocitySelection(int nGroupId_)
{
    MATERIAL& _material = m_pConfig->group[nGroupId_].part.material ;
    ui->ComVelocitySelection->clear();

    QString _strTmp[3];
    _strTmp[0].sprintf("%s" , _material.strName) ;
    _strTmp[1].sprintf("[L]%.0f" , _material.fVelocityLon) ;
    _strTmp[2].sprintf("[T]%.0f" , _material.fVelocityTran) ;

    ui->ComVelocitySelection->addItem(_strTmp[0]);
    ui->ComVelocitySelection->addItem(_strTmp[1]);
    ui->ComVelocitySelection->addItem(_strTmp[2]);
}
void DopplerGroupTab::InitComBoxMaterialSelection(int nGroupId_)
{
    QList<MATERIAL*>* _list = m_pConfig->material ;
    ui->ComMaterial->clear();
    QStringList _strList;

    int _nIndex = 0;
    for(int i = 0 ; i< _list->count() ; i++)
    {
        MATERIAL* _pMaterial = _list->at(i) ;
        QString _str ;
        _str.sprintf("[%s][L:%.0f][T:%.0f]" , _pMaterial->strName, _pMaterial->fVelocityLon , _pMaterial->fVelocityTran ) ;
        _strList.append(_str);
        if(!strcmp( _pMaterial->strName , m_pConfig->group[nGroupId_].part.material.strName) )
            _nIndex= i ;
    }
    ui->ComMaterial->addItems(_strList);
    ui->ComMaterial->setCurrentIndex(_nIndex);
}

void DopplerGroupTab::UpdateProbeConfig(int nGroupId_ , int bIsRx_)
{
    GROUP_CONFIG& group = m_pConfig->group[nGroupId_] ;
    PROBE_CONFIG& _probe = group.probe[bIsRx_ ? 1 : 0] ;

    QString _str[4] ;
    _str[0].sprintf("Element Qty  : Pri[%3d]   Sec[%3d] ", _probe.nElementPri ,    _probe.nElementSec ) ;
    _str[1].sprintf("Element Size : Pri[%2.1f] Sec[%2.1f]  mm", _probe.fSizePri ,  _probe.fSizeSec)    ;
    _str[2].sprintf("Element Pitch: Pri[%2.1f] Sec[%2.1f]  mm" , _probe.fPitchPri, _probe.fPitchSec) ;
    _str[3].sprintf("Element Frequency: %.1f MHz" , _probe.fFrequency);
    if(bIsRx_)
    {
        ui->BtnProbeSelection_2->setText(_probe.strName);
        ui->LabelProbeT_Line1_2->setText(_str[0]);
        ui->LabelProbeT_Line2_2->setText(_str[1]);
        ui->LabelProbeT_Line3_2->setText(_str[2]);
        ui->LabelProbeT_Line4_2->setText(_str[3]);
    }
    else
    {
        ui->BtnProbeSelection->setText(_probe.strName);
        ui->LabelProbeT_Line1->setText(_str[0]);
        ui->LabelProbeT_Line2->setText(_str[1]);
        ui->LabelProbeT_Line3->setText(_str[2]);
        ui->LabelProbeT_Line4->setText(_str[3]);
    }

}

void DopplerGroupTab::UpdateWedgeConfig(int nGroupId_ , int bIsRx_)
{
    GROUP_CONFIG& group = m_pConfig->group[nGroupId_] ;
    WEDGE_CONFIG& _wedge = group.wedge[bIsRx_ ? 1 : 0] ;

    QString _str[4] ;
    _str[0].sprintf("Wedge Angle: %2.1f Roof Angle: %2.1f" , _wedge.fWedgeAngle , _wedge.fRoofAngle ) ;
    _str[1].sprintf("Velocity Longtitude: %.0f Transmmit: %.0f" , _wedge.fVelocityLon , _wedge.fVelocityTra ) ;
    _str[2].sprintf("Wedge Type: %s Wedge Direction: %s",
                    _wedge.eType ? "UT" : "PA" , _wedge.eDirection ? "NORMAL" : "INVERSE");
    if(_wedge.eType)
    {
        _str[3].sprintf("Reference Point: %.1f mm Wedge Delay: %.2f us" ,
                        _wedge.fRefPoint , _wedge.nWedgeDelay /1000.0) ;
    }
    else
    {
        _str[3].sprintf("First Height: %.1f  Offset Fir: %.1f  Sec: %.1f" ,
                       _wedge.fHeigtFirst , _wedge.fOffsetFir , _wedge.fOffsetSec) ;
    }

    if(bIsRx_)
    {
        ui->BtnWedgeSelection_2->setText(_wedge.strName);
        ui->LabelWedgeT_Line1_2->setText(_str[0]);
        ui->LabelWedgeT_Line2_2->setText(_str[1]);
        ui->LabelWedgeT_Line3_2->setText(_str[2]);
        ui->LabelWedgeT_Line4_2->setText(_str[3]);
    }
    else
    {
        ui->BtnWedgeSelection->setText(_wedge.strName);
        ui->LabelWedgeT_Line1->setText(_str[0]);
        ui->LabelWedgeT_Line2->setText(_str[1]);
        ui->LabelWedgeT_Line3->setText(_str[2]);
        ui->LabelWedgeT_Line4->setText(_str[3]);
    }

}

void DopplerGroupTab::UpdateLawConfig(int nGroupId_)
{

    GROUP_CONFIG& group = m_pConfig->group[nGroupId_] ;
    LAW_CONFIG& _law = group.law ;
    ui->ComLawType->setCurrentIndex(_law.eLawType);
    //************  angle  setting ***************
    ui->ComAngleType->setCurrentIndex(_law.eAngleType);
    ui->ComAngleType->setEnabled(false);

    ui->ValuePriSteerStart->setEnabled(false);
    ui->ValuePriSteerStep->setEnabled(false);
    ui->ValuePriSteerStop->setEnabled(false);

    ui->ValueSecSteerStart->setEnabled(false);
    ui->ValueSecSteerStep->setEnabled(false);
    ui->ValueSecSteerStop->setEnabled(false);

    ui->ValueSkewStart->setEnabled(false);
    ui->ValueSkewStep->setEnabled(false);
    ui->ValueSkewStop->setEnabled(false);

    ui->ValueRefractStart->setValue(_law.nAngleStartRefract / 10.0);
    ui->ValueRefractStep->setValue(_law.nAngleStepRefract / 10.0);
    ui->ValueRefractStop->setValue(_law.nAngleStopRefract / 10.0);
    //************************************************
    //************ focal point
    ui->ComFocalType->setCurrentIndex(_law.eFocalType);
    ui->ValueFocusPositionStart->setValue(_law.fPositionStart);
    ui->ValueFocusPositionStop->setValue(_law.fPositionStop);
    ui->ValueFocusPositionStep->setValue(_law.fPositionStep);
    ui->ValueFocusOffsetStart->setValue(_law.fOffsetStart);
    ui->ValueFocusOffsetStop->setValue(_law.fOffsetStop);
    ui->ValueFocusDepthStart->setValue(_law.fDepthStart);
    ui->ValueFocusDepthStop->setValue(_law.fDepthStop);
    //***********************************************
    //************ element selection
    ui->ValueElementQtyPri->setValue(_law.nElemQtyFir);
    ui->ValueElementQtySec->setValue(_law.nElemQtySec);
    ui->ValueElementStartPri->setValue(_law.nFirstElemFir);
    ui->ValueElementStopPri->setValue(_law.nLastElemFir);
    ui->ValueElementStepPri->setValue(_law.nElemStepFir);

    ui->ValueElementStartSec->setValue(_law.nFirstElemSec);
    ui->ValueElementStopSec->setValue(_law.nLastElemSec);
    ui->ValueElementStepSec->setValue(_law.nElemStepSec);
}

void DopplerGroupTab::UpdateGroupConfig (int nGroupId_)
{
    GROUP_CONFIG& group = m_pConfig->group[nGroupId_] ;
    //*******   UT setting  **********//
    ui->ValueGain->setValue(group.fGain) ;
    ui->ValueStart->setValue(group.fSampleStart);
    ui->ValueRange->setValue(group.fSampleRange);
    ui->ValueWedgeDelay->setValue(group.nWedgeDelay / 1000.0);
    ui->ValueVelocity->setValue(group.fVelocity);
    UpdateVelocitySelection(nGroupId_) ;

    ui->ValuePulser->setValue(group.nTrigeStart);
    ui->ValueReceiver->setValue(group.nReceiveStart);
    ui->ComFilter->setCurrentIndex(group.eFileter);
    ui->ComRectifier->setCurrentIndex(group.eRectifier);
    ui->CheckVideoFilter->setCheckState(group.bVedioFilter?Qt::Checked :Qt::Unchecked);
    ui->ValuePointQty->setValue(group.nPointQty);
    ui->ValueSumGain->setValue(group.fSumGain);
    ui->ComAverage->setCurrentIndex(group.eAveraging);
    //************************************************
    //********** Probe and Wedge **********//
    ui->ComGroupMode->setCurrentIndex(group.eGroupMode);
    UpdateProbeConfig(nGroupId_ , 0);
    UpdateProbeConfig(nGroupId_ , 1);
    UpdateWedgeConfig(nGroupId_ , 0);
    UpdateWedgeConfig(nGroupId_ , 1);
    //***********************************************
    //**********    Focallaw    ***************//
    UpdateLawConfig(nGroupId_);
    //***********************************************
    //**********   Gate and Sizeing curves
    int _nGate = ui->ComGateSelect->currentIndex() ;
    GATE_CONFIG& gate = group.gate[_nGate] ;
    ui->ValueGateStart->setValue(gate.fStart);
    ui->ValueGateWidth->setValue(gate.fWidth);
    ui->ValueGateHeight->setValue(gate.nThreshold);
    ui->ComGateSync->setCurrentIndex(gate.eSynChro);
    ui->ComGateMeasure->setCurrentIndex(gate.eMeasure);

    ui->BoxSizingCurves->setEnabled(false);
    //***********************************************
    //  ********** geometry
    InitComBoxMaterialSelection(nGroupId_) ;
    ui->ComGeometry->setCurrentIndex(group.part.eGeometry);
    ui->ValuePartThickness->setValue(group.part.fThickness);
    ui->ValuePartLength->setValue(group.part.afSize[0]);
    ui->ValuePartWidth->setValue(group.part.afSize[1]);
    ui->CheckUnifiedPartSetting->setCheckState(m_pConfig->common.bUnifiedPart ? Qt::Checked : Qt::Unchecked);
    if(nGroupId_ && m_pConfig->common.bUnifiedPart)   ui->BoxPart->setEnabled(false);

    ui->ValueScanOffset->setValue(group.fScanOffset);
    ui->ValueIndexOffset->setValue(group.fIndexOffset);
    ui->ComSkewAngle->setCurrentIndex(group.eSkew);
    //************************************************
    //*********** measure
    ui->CheckMeasureShow->setCheckState(group.bShowMeasure ? Qt::Checked : Qt::Unchecked );
    ui->ComField1->setCurrentIndex(group.aeMeasureType[0]);
    ui->ComField2->setCurrentIndex(group.aeMeasureType[1]);
    ui->ComField3->setCurrentIndex(group.aeMeasureType[2]);
    ui->ComField4->setCurrentIndex(group.aeMeasureType[3]);
    ui->ComField5->setCurrentIndex(group.aeMeasureType[4]);
    ui->CheckCursorShow->setCheckState(group.bShowCursor ? Qt::Checked : Qt::Unchecked );
    ui->ValueARef->setValue(group.fARef);
    ui->ValueAMes->setValue(group.fAMes);
    ui->ValueURef->setValue(group.fURef);
    ui->ValueUMes->setValue(group.fUMes);
    ui->ValueSRef->setValue(group.fSRef);
    ui->ValueSMes->setValue(group.fSMes);
    ui->ValueIRef->setValue(group.fIRef);
    ui->ValueIMes->setValue(group.fIMes);


}


void DopplerGroupTab::slotGainValueChange(double fValue_)
{
    //qDebug("slotGainValueChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.fGain  = fValue_ ;
    emit signalValueChanged(PARAMETER_GAIN) ;
}

void DopplerGroupTab::slotSampleStartChange(double fValue_)
{
    //qDebug("slotSampleStartChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.fSampleStart  = fValue_ ;
    emit signalValueChanged(PARAMETER_SAMPLE_START);
}

void DopplerGroupTab::slotSampleRangeChange(double fValue_)
{
    //qDebug("slotSampleRangeChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.fSampleRange  = fValue_ ;
    emit signalValueChanged(PARAMETER_SAMPLE_RANGE);
}

void DopplerGroupTab::slotVelocityChange(double fValue_)
{
    //qDebug("slotVelocityChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.fVelocity  = fValue_ ;
    emit signalValueChanged(PARAMETER_VELOCITY);
}

void DopplerGroupTab::slotVelocityReselect(int nValue_)
{
    //qDebug("slotVelocityReselect %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    if(nValue_ == 1)
    {
        ui->ValueVelocity->setValue(group.part.material.fVelocityLon);
    }
    else if (nValue_ == 2)
    {
        ui->ValueVelocity->setValue(group.part.material.fVelocityTran);
    }
    ui->ComVelocitySelection->setCurrentIndex(0);
}

void DopplerGroupTab::slotWedgeDelayChanged(double fValue_)
{
    //qDebug("slotWedgeDelayChanged %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.nWedgeDelay   = fValue_ * 1000 ;
    emit signalValueChanged(PARAMETER_WEDGE_DELAY);
}

void DopplerGroupTab::slotPulserStartChanged(int nValue_)
{
    //qDebug("slotPulserStartChanged %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.nTrigeStart = nValue_  ;
    emit signalValueChanged(PARAMETER_PULSER_START);
}

void DopplerGroupTab::slotReceiverStartChanged(int nValue_)
{
    //qDebug("slotReceiverStartChanged %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.nReceiveStart = nValue_  ;
    emit signalValueChanged(PARAMETER_RECEIVER_START);
}

void DopplerGroupTab::slotFilterChange(int nValue_)
{
    //qDebug("slotFilterChange %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.eFileter = (setup_FILTER_MODE)nValue_  ;
    emit signalValueChanged(PARAMETER_FILTER);
}

void DopplerGroupTab::slotRectifyChange(int nValue_)
{
    //qDebug("slotRectifyChange %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.eRectifier = (setup_RECTIFIER_MODE)nValue_  ;
    emit signalValueChanged(PARAMETER_RECTIFIER);
}
void DopplerGroupTab::slotVideoFilterOn(bool bValue_)
{
    //qDebug(" slotVideoFilterOn %d" , bValue_ );
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.bVedioFilter = bValue_  ;
    emit signalValueChanged(PARAMETER_VEDIO_ONOFF);
}
void DopplerGroupTab::slotPointQtyChange(int nValue_)
{
    //qDebug("slotPointQtyChange %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.nPointQty = nValue_  ;
    emit signalValueChanged(PARAMETER_POINT_QTY);

}
void DopplerGroupTab::slotSumGainChange(double fValue_)
{
    //qDebug("slotSumGainChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.fSumGain  = fValue_ ;
    emit signalValueChanged(PARAMETER_SUM_GAIN);
}
void DopplerGroupTab::slotAverageChange(int nValue_)
{
    //qDebug("slotAverageChange %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.eAveraging  = (setup_EVERAGE_MODE)nValue_ ;
    emit signalValueChanged(PARAMETER_AVERAGE);
}
void DopplerGroupTab::slotGroupModeChange(int nValue_)
{
    //qDebug("slotGroupModeChange %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.eGroupMode  = (setup_GROUP_MODE)nValue_ ;
    emit signalValueChanged(PARAMETER_GROUP_MODE);
}
void DopplerGroupTab::slotProbeSelectBtnClickedTX()
{
    //qDebug(" slotProbeSelectBtnClickedTX " );
}
void DopplerGroupTab::slotWedgeSelecBtnClickedTX()
{
     //qDebug(" slotWedgeSelecBtnClickedTX " );
}
void DopplerGroupTab::slotProbeSelectBtnClickedRX()
{
     //qDebug(" slotProbeSelectBtnClickedRX " );
}
void DopplerGroupTab::slotWedgeSelectBtnClickedRX()
{
     //qDebug(" slotWedgeSelectBtnClickedRX " );
}
void DopplerGroupTab::slotLawTypeChange(int nValue_)
{
    //qDebug("slotLawTypeChange %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.eLawType  = (setup_LAW_TYPE)nValue_ ;
    emit signalValueChanged(PARAMETER_LAW_TYPE);
}
void DopplerGroupTab::slotAngleTypeChange(int nValue_)
{
    //qDebug("slotAngleTypeChange %d" , nValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.eAngleType  = (setup_ANGLE_TYPE)nValue_ ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotPriSteeringAngleStartChange(double fValue_)
{
    //qDebug("slotPriSteeringAngleStartChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStartPriSteer  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotPriSteeringAngleStopChange(double fValue_)
{
    //qDebug("slotPriSteeringAngleStopChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStopPriSteer  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotPriSteeringAngleStepChange(double fValue_)
{
    //qDebug("slotPriSteeringAngleStepChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStepPriSteer  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotSecSteeringAngleStopChange(double fValue_)
{
    //qDebug("slotSecSteeringAngleStopChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStopSecSteer  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotSecSteeringAngleStepChange(double fValue_)
{
    //qDebug("slotSecSteeringAngleStepChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStopSecSteer  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotSecSteeringAngleStartChange(double fValue_)
{
    //qDebug("slotSecSteeringAngleStartChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStartSecSteer  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotRefractAngleStartChange(double fValue_)
{
    //qDebug("slotRefractAngleStartChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStartRefract  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotRefractAngleStopChange(double fValue_)
{
    //qDebug("slotRefractAngleStopChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStopRefract  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotRefractAngleStepChange(double fValue_)
{
    //qDebug("slotRefractAngleStepChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStepRefract  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotSkewAngleStartChange(double fValue_)
{
    //qDebug("slotSkewAngleStartChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStartBeamSkew  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotSkewAngleStopChange(double fValue_)
{
    //qDebug("slotSkewAngleStopChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStopBeamSkew  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotSkewAngleStepChange(double fValue_)
{
    //qDebug("slotSkewAngleStepChange %f" , fValue_);
    GROUP_CONFIG& group = m_pConfig->group[m_nGroupId] ;
    group.law.nAngleStepBeamSkew  = fValue_ * 10 ;
    emit signalValueChanged(PARAMETER_LAW_ANGLE);
}
void DopplerGroupTab::slotFocalTypeChange(int nValue_)
{
    //qDebug("slotFocalTypeChange %d" , nValue_);
}
void DopplerGroupTab::slotFocusPositionStartChange(double fValue_)
{
    //qDebug("slotFocusPositionStartChange %f" , fValue_);
}
void DopplerGroupTab::slotFocusPositionStopChange(double fValue_)
{
    //qDebug("slotFocusPositionStopChange %f" , fValue_);
}
void DopplerGroupTab::slotFocusPositionStepChange(double fValue_)
{
    //qDebug("slotFocusPositionStepChange %f" , fValue_);
}
void DopplerGroupTab::slotFocusOffsetStart(double fValue_)
{
    //qDebug("slotFocusOffsetStart %f" , fValue_);
}
void DopplerGroupTab::slotFocusOffsetStop(double fValue_)
{
    //qDebug("slotFocusOffsetStop %f" , fValue_);
}
void DopplerGroupTab::slotFocusDepthStart(double fValue_)
{
    //qDebug("slotFocusDepthStart %f" , fValue_);
}
void DopplerGroupTab::slotFocusDepthStop(double fValue_)
{
    //qDebug("slotFocusDepthStop %f" , fValue_);
}
void DopplerGroupTab::slotElementSelectedQty(int nValue_)
{
    //qDebug("slotElementSelectedQty %d" , nValue_);
}
void DopplerGroupTab::slotElementSelectedStart(int nValue_)
{
    //qDebug("slotElementSelectedStart %d" , nValue_);
}
void DopplerGroupTab::slotElementSelectedStop(int nValue_)
{
    //qDebug("slotElementSelectedStop %d" , nValue_);
}
void DopplerGroupTab::slotElementSelectedStep(int nValue_)
{
    //qDebug("slotElementSelectedStep %d" , nValue_);
}
void DopplerGroupTab::slotElementSelectedQtySec(int nValue_)
{
    //qDebug("slotElementSelectedQtySec %d" , nValue_);
}
void DopplerGroupTab::slotElementSelectedStartSec(int nValue_)
{
    //qDebug("slotElementSelectedStartSec %d" , nValue_);
}
void DopplerGroupTab::slotElementSelectedStopSec(int nValue_)
{
    //qDebug("slotElementSelectedStopSec %d" , nValue_);
}
void DopplerGroupTab::slotElementSelectedStepSec(int nValue_)
{
    //qDebug("slotElementSelectedStepSec %d" , nValue_);
}
void DopplerGroupTab::slotCurrentGateChange(int nValue_)
{
    //qDebug("slotCurrentGateChange %d" , nValue_);
}

void DopplerGroupTab::slotGateStartChange(double fValue_)
{
    //qDebug("slotGateStartChange %f" , fValue_);
}
void DopplerGroupTab::slotGateWidthChange(double fValue_)
{
    //qDebug("slotGateWidthChange %f" , fValue_);
}
void DopplerGroupTab::slotGateSync(int nValue_)
{
    //qDebug("slotGateSync %d" , nValue_);
}
void DopplerGroupTab::slotGateHeight(int nValue_)
{
    //qDebug("slotGateHeight %d" , nValue_);
}
void DopplerGroupTab::slotGateMeasure(int nValue_)
{
    //qDebug("slotGateMeasure %d" , nValue_);
}
void DopplerGroupTab::slotGeometryChange(int nValue_)
{
    //qDebug("slotGeometryChange %d" , nValue_);
}
void DopplerGroupTab::slotMaterialSelect(int nValue_)
{
    //qDebug("slotMaterialSelect %d" , nValue_);
}
void DopplerGroupTab::slotGeometrySizeChange1(double fValue_)
{
    //qDebug("slotGeometrySizeChange1 %f" , fValue_);
}
void DopplerGroupTab::slotGeometrySizeChange2(double fValue_)
{
    //qDebug("slotGeometrySizeChange2 %f" , fValue_);
}
void DopplerGroupTab::slotGeometrySizeChange3(double fValue_)
{
    //qDebug("slotGeometrySizeChange3 %f" , fValue_);
}
void DopplerGroupTab::slotGeometryUnified(bool bValue_)
{
    //qDebug("slotGeometryUnified %d" , bValue_);
}
void DopplerGroupTab::slotScanOffsetChange(double fValue_)
{
    //qDebug("slotScanOffsetChange %f" , fValue_);
}
void DopplerGroupTab::slotIndexOffsetChange(double fValue_)
{
    //qDebug("slotIndexOffsetChange %f" , fValue_);
}
void DopplerGroupTab::slotWedgeSkewAngle(int nValue_)
{
    //qDebug("slotWedgeSkewAngle %d" , nValue_);
}
void DopplerGroupTab::slotLoadPartFile()
{
     //qDebug(" slotLoadPartFile " );
}
void DopplerGroupTab::slotShowPartFile(bool bValue_)
{
     //qDebug(" slotShowPartFile  %d" , bValue_);
}
void DopplerGroupTab::slotShowMeasureValue(bool bValue_)
{
    //qDebug(" slotShowMeasureValue  %d" , bValue_);
}
void DopplerGroupTab::slotMeasureValueSelect1(int nValue_)
{
    //qDebug("slotMeasureValueSelect1 %d" , nValue_);
}
void DopplerGroupTab::slotMeasureValueSelect2(int nValue_)
{
    //qDebug("slotMeasureValueSelect2 %d" , nValue_);
}
void DopplerGroupTab::slotMeasureValueSelect3(int nValue_)
{
    //qDebug("slotMeasureValueSelect3 %d" , nValue_);
}
void DopplerGroupTab::slotMeasureValueSelect4(int nValue_)
{
    //qDebug("slotMeasureValueSelect4 %d" , nValue_);
}
void DopplerGroupTab::slotMeasureValueSelect5(int nValue_)
{
    //qDebug("slotMeasureValueSelect5 %d" , nValue_);
}
void DopplerGroupTab::slotCursorShow(bool bValue_)
{
    //qDebug("slotCursorShow %d" , bValue_);
}
void DopplerGroupTab::slotCursorARef(double fValue_)
{
    //qDebug("slotCursorARef %f" , fValue_);
}
void DopplerGroupTab::slotCursorAMes(double fValue_)
{
    //qDebug("slotCursorAMes %f" , fValue_);
}
void DopplerGroupTab::slotCursorURef(double fValue_)
{
    //qDebug("slotCursorURef %f" , fValue_);
}
void DopplerGroupTab::slotCursorUMes(double fValue_)
{
    //qDebug("slotCursorUMes %f" , fValue_);
}
void DopplerGroupTab::slotCursorSRef(double fValue_)
{
    //qDebug("slotCursorSRef %f" , fValue_);
}
void DopplerGroupTab::slotCursorIRef(double fValue_)
{
    //qDebug("slotCursorIRef %f" , fValue_);
}
void DopplerGroupTab::slotCursorSMes(double fValue_)
{
    //qDebug("slotCursorSMes %f" , fValue_);
}
void DopplerGroupTab::slotCursorIMes(double fValue_)
{
    //qDebug("slotCursorIMes %f" , fValue_);
}
